{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-01-09T13:18:17.308607Z",
     "start_time": "2025-01-09T13:18:17.286595Z"
    }
   },
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.feature_extraction.text import CountVectorizer, TfidfVectorizer\n",
    "from sklearn.preprocessing import MinMaxScaler, StandardScaler\n",
    "from sklearn.feature_selection import VarianceThreshold\n",
    "from sklearn.decomposition import PCA\n",
    "import jieba\n",
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer"
   ],
   "outputs": [],
   "execution_count": 2
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T13:19:21.643684Z",
     "start_time": "2025-01-09T13:19:21.632296Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.feature_extraction import DictVectorizer\n",
    "\n",
    "def dictvec():\n",
    "    \"\"\"\n",
    "    字典数据抽取\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 实例化 DictVectorizer\n",
    "    # sparse改为True, 输出的是每个不为零位置的坐标，稀疏矩阵可以节省存储空间\n",
    "    # 如果矩阵中存在大量的0，sparse存储只记录非零位置，节省空间的作用\n",
    "    # Vectorizer 的中文含义是矢量器，指的是将数据转换为特征向量的工具\n",
    "    dict1 = DictVectorizer(sparse=True)  # 这里设置sparse=True来返回稀疏矩阵\n",
    "\n",
    "    # 每个样本都是一个字典，共有三个样本\n",
    "    # 使用fit_transform方法将字典数据转换为特征矩阵\n",
    "    data = dict1.fit_transform([{'city': '北京', 'temperature': 100},\n",
    "                                {'city': '上海', 'temperature': 60},\n",
    "                                {'city': '深圳', 'temperature': 30}])\n",
    "    # 打印转换后的稀疏矩阵\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "\n",
    "    # 打印字典中的一些类别数据，转换后的特征名称\n",
    "    print(dict1.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "\n",
    "    # 使用inverse_transform方法将特征矩阵逆转回字典数据\n",
    "    print(dict1.inverse_transform(data))  # 查看每个特征代表的含义，逆转回去\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "# 调用 dictvec 函数\n",
    "dictvec()"
   ],
   "id": "b89c9506e147a7cc",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<Compressed Sparse Row sparse matrix of dtype 'float64'\n",
      "\twith 6 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t1.0\n",
      "  (0, 3)\t100.0\n",
      "  (1, 0)\t1.0\n",
      "  (1, 3)\t60.0\n",
      "  (2, 2)\t1.0\n",
      "  (2, 3)\t30.0\n",
      "--------------------------------------------------\n",
      "['city=上海' 'city=北京' 'city=深圳' 'temperature']\n",
      "--------------------------------------------------\n",
      "[{'city=北京': np.float64(1.0), 'temperature': np.float64(100.0)}, {'city=上海': np.float64(1.0), 'temperature': np.float64(60.0)}, {'city=深圳': np.float64(1.0), 'temperature': np.float64(30.0)}]\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T13:20:16.535231Z",
     "start_time": "2025-01-09T13:20:16.525138Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "\n",
    "def couvec():\n",
    "    \"\"\"\n",
    "    词频特征提取：使用 CountVectorizer 提取文本数据的词频特征\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 实例化 CountVectorizer\n",
    "    # min_df: 词频的最小文档出现频率阈值，表示只有在至少 min_df 个文档中出现的词才会被考虑\n",
    "    # 默认会去除出现频率较低的词，比如单字母词，认为这些对整个语料库的语义影响较小\n",
    "    # 这里设置 min_df=2，表示一个词至少出现在 2 个文档中才会被作为特征\n",
    "    vector = CountVectorizer(min_df=2)\n",
    "\n",
    "    # 输入样本数据并进行转换\n",
    "    # 这个数据包含了 3 条句子，CountVectorizer 会统计每个词在每个句子中出现的频率\n",
    "    res = vector.fit_transform([\n",
    "        \"life is short, i like python life\",  # 文档 1\n",
    "        \"life is too long, i dislike python\", # 文档 2\n",
    "        \"life is short\"                       # 文档 3\n",
    "    ])\n",
    "\n",
    "    # 打印转换后的特征名称（所有被提取的词汇）\n",
    "    print(vector.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    \n",
    "    # 打印转换后的结果（稀疏矩阵）\n",
    "    print(res)\n",
    "    print('-' * 50)\n",
    "    \n",
    "    # 打印转换结果的类型，查看是否是稀疏矩阵\n",
    "    print(type(res))\n",
    "    \n",
    "    # 打印每个词在不同文档中出现的次数，稀疏矩阵转为数组形式\n",
    "    print('-' * 50)\n",
    "    print(res.toarray())  # 稀疏矩阵转换为普通数组\n",
    "    print('-' * 50)\n",
    "\n",
    "    # 使用 inverse_transform 方法查看每个特征对应的原始文本（逆转回去）\n",
    "    print(vector.inverse_transform(res))\n",
    "\n",
    "# 调用 couvec 函数\n",
    "couvec()"
   ],
   "id": "179b0820762134de",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 10 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t2\n",
      "  (0, 0)\t1\n",
      "  (0, 3)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 1)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 3)\t1\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T13:20:48.164756Z",
     "start_time": "2025-01-09T13:20:48.158061Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.feature_extraction.text import CountVectorizer\n",
    "\n",
    "def countvec():\n",
    "    \"\"\"\n",
    "    对文本进行特征值化，单个汉字和单个字母不统计，因为单个汉字和字母没有实际意义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 实例化 CountVectorizer\n",
    "    # 默认情况下，CountVectorizer 会提取文本中的所有单词，并计算每个单词在文本中的频率\n",
    "    # 单个字母或者单个汉字默认会被忽略，因为它们通常没有语义\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    # 输入样本数据并进行转换\n",
    "    # 这里有两个文本句子，CountVectorizer 会统计每个词在句子中的出现频率\n",
    "    data = cv.fit_transform([\n",
    "        \"人生苦短，我喜欢 python python\",  # 文档 1\n",
    "        \"人生漫长，不用 python\"             # 文档 2\n",
    "    ])\n",
    "\n",
    "    # 打印转换后的特征名称（即被提取的词汇）\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "\n",
    "    # 打印转换后的稀疏矩阵（只记录非零位置）\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "\n",
    "    # 使用 toarray 方法将稀疏矩阵转换为普通的数组\n",
    "    # 稀疏矩阵表示的是大部分为 0 的矩阵，通过 toarray() 可以查看矩阵的完整数据\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "# 调用 countvec 函数\n",
    "countvec()\n"
   ],
   "id": "7b63e5395f61c5a3",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '我喜欢']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 6 stored elements and shape (2, 5)>\n",
      "  Coords\tValues\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T14:07:59.953980Z",
     "start_time": "2025-01-09T14:07:59.948788Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def couvec():\n",
    "    # 实例化CountVectorizer\n",
    "    # max_df, min_df整数：指每个词的所有文档词频数不小于最小值，出现该词的文档数目小于等于max_df\n",
    "    # max_df, min_df小数(0-1之间的）：某个词的出现的次数／所有文档数量\n",
    "    # min_df=2\n",
    "    # 默认会去除单个字母的单词，默认认为这个词对整个样本没有影响,认为其没有语义\n",
    "    vector = CountVectorizer(min_df=2)\n",
    "\n",
    "    # 调用fit_transform输入并转换数据\n",
    "\n",
    "    res = vector.fit_transform(\n",
    "        [\"life is  short,i like python life\",\n",
    "         \"life is too long,i dislike python\",\n",
    "         \"life is short\"])\n",
    "\n",
    "    # 打印结果,把每个词都分离了\n",
    "    print(vector.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(res)\n",
    "    print('-' * 50)\n",
    "    print(type(res))\n",
    "    # 对照feature_names，标记每个词出现的次数\n",
    "    print('-' * 50)\n",
    "    print(res.toarray())  #稀疏矩阵转换为数组\n",
    "    print('-' * 50)\n",
    "    #拿每个样本里的特征进行显示\n",
    "    print(vector.inverse_transform(res))\n",
    "\n",
    "\n",
    "couvec()"
   ],
   "id": "de7c395fa27ebf74",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['is' 'life' 'python' 'short']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 10 stored elements and shape (3, 4)>\n",
      "  Coords\tValues\n",
      "  (0, 1)\t2\n",
      "  (0, 0)\t1\n",
      "  (0, 3)\t1\n",
      "  (0, 2)\t1\n",
      "  (1, 1)\t1\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (2, 1)\t1\n",
      "  (2, 0)\t1\n",
      "  (2, 3)\t1\n",
      "--------------------------------------------------\n",
      "<class 'scipy.sparse._csr.csr_matrix'>\n",
      "--------------------------------------------------\n",
      "[[1 2 1 1]\n",
      " [1 1 1 0]\n",
      " [1 1 0 1]]\n",
      "--------------------------------------------------\n",
      "[array(['life', 'is', 'short', 'python'], dtype='<U6'), array(['life', 'is', 'python'], dtype='<U6'), array(['life', 'is', 'short'], dtype='<U6')]\n"
     ]
    }
   ],
   "execution_count": 6
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T14:08:13.261999Z",
     "start_time": "2025-01-09T14:08:13.257309Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def countvec():\n",
    "    \"\"\"\n",
    "    对文本进行特征值化,单个汉字单个字母不统计，因为单个汉字字母没有意义\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([\"人生苦短，我喜欢 python python\", \"人生漫长，不用 python\"])\n",
    "\n",
    "    print(cv.get_feature_names_out())\n",
    "    print('-' * 50)\n",
    "    print(data)  #稀疏存储，只记录非零位置\n",
    "    print('-' * 50)\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "countvec()"
   ],
   "id": "936f7f9b6a81b162",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['python' '不用' '人生漫长' '人生苦短' '我喜欢']\n",
      "--------------------------------------------------\n",
      "<Compressed Sparse Row sparse matrix of dtype 'int64'\n",
      "\twith 6 stored elements and shape (2, 5)>\n",
      "  Coords\tValues\n",
      "  (0, 3)\t1\n",
      "  (0, 4)\t1\n",
      "  (0, 0)\t2\n",
      "  (1, 0)\t1\n",
      "  (1, 2)\t1\n",
      "  (1, 1)\t1\n",
      "--------------------------------------------------\n",
      "[[2 0 0 1 1]\n",
      " [1 1 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T14:22:45.546492Z",
     "start_time": "2025-01-09T14:22:45.538809Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def cutword():\n",
    "    \"\"\"\n",
    "    通过jieba对中文进行分词\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    con1 = jieba.cut(\"今天很残酷，明天更残酷，后天很美好，但绝对大部分是死在明天晚上，所以每个人不要放弃今天。\")\n",
    "\n",
    "    con2 = jieba.cut(\"我们看到的从很远星系来的光是在几百万年之前发出的，这样当我们看到宇宙时，我们是在看它的过去。\")\n",
    "\n",
    "    con3 = jieba.cut(\n",
    "        \"如果只用一种方式了解某样事物，你就不会真正了解它。了解事物真正含义的秘密取决于如何将其与我们所了解的事物相联系。\")\n",
    "\n",
    "    # 转换成列表\n",
    "    print(type(con1))\n",
    "    print('-' * 50)\n",
    "    # 把生成器转换成列表\n",
    "    content1 = list(con1)\n",
    "    content2 = list(con2)\n",
    "    content3 = list(con3)\n",
    "    print(content1)\n",
    "    print(content2)\n",
    "    print(content3)\n",
    "    # 把列表转换成字符串,每个词之间用空格隔开\n",
    "    print('-' * 50)\n",
    "    c1 = ' '.join(content1)\n",
    "    c2 = ' '.join(content2)\n",
    "    c3 = ' '.join(content3)\n",
    "\n",
    "    return c1, c2, c3\n",
    "\n",
    "\n",
    "def hanzivec():\n",
    "    \"\"\"\n",
    "    中文特征值化\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    c1, c2, c3 = cutword()  #jieba分词好的中文文本\n",
    "    print('-' * 50)\n",
    "    print(c1)  #把分词好的文本打印出来\n",
    "    print(c2)\n",
    "    print(c3)\n",
    "    print('-' * 50)\n",
    "\n",
    "    cv = CountVectorizer()\n",
    "\n",
    "    data = cv.fit_transform([c1, c2, c3])\n",
    "\n",
    "    print(cv.get_feature_names_out())  #把处理好后的特征名称打印出来\n",
    "\n",
    "    print(data.toarray())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "# cutword()\n",
    "hanzivec()"
   ],
   "id": "ce669ba201729ab1",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "--------------------------------------------------\n",
      "['今天', '很', '残酷', '，', '明天', '更', '残酷', '，', '后天', '很', '美好', '，', '但', '绝对', '大部分', '是', '死', '在', '明天', '晚上', '，', '所以', '每个', '人', '不要', '放弃', '今天', '。']\n",
      "['我们', '看到', '的', '从', '很', '远', '星系', '来', '的', '光是在', '几百万年', '之前', '发出', '的', '，', '这样', '当', '我们', '看到', '宇宙', '时', '，', '我们', '是', '在', '看', '它', '的', '过去', '。']\n",
      "['如果', '只用', '一种', '方式', '了解', '某样', '事物', '，', '你', '就', '不会', '真正', '了解', '它', '。', '了解', '事物', '真正', '含义', '的', '秘密', '取决于', '如何', '将', '其', '与', '我们', '所', '了解', '的', '事物', '相', '联系', '。']\n",
      "--------------------------------------------------\n",
      "--------------------------------------------------\n",
      "今天 很 残酷 ， 明天 更 残酷 ， 后天 很 美好 ， 但 绝对 大部分 是 死 在 明天 晚上 ， 所以 每个 人 不要 放弃 今天 。\n",
      "我们 看到 的 从 很 远 星系 来 的 光是在 几百万年 之前 发出 的 ， 这样 当 我们 看到 宇宙 时 ， 我们 是 在 看 它 的 过去 。\n",
      "如果 只用 一种 方式 了解 某样 事物 ， 你 就 不会 真正 了解 它 。 了解 事物 真正 含义 的 秘密 取决于 如何 将 其 与 我们 所 了解 的 事物 相 联系 。\n",
      "--------------------------------------------------\n",
      "['一种' '不会' '不要' '之前' '了解' '事物' '今天' '光是在' '几百万年' '发出' '取决于' '只用' '后天' '含义'\n",
      " '大部分' '如何' '如果' '宇宙' '我们' '所以' '放弃' '方式' '明天' '星系' '晚上' '某样' '残酷' '每个'\n",
      " '看到' '真正' '秘密' '绝对' '美好' '联系' '过去' '这样']\n",
      "[[0 0 1 0 0 0 2 0 0 0 0 0 1 0 1 0 0 0 0 1 1 0 2 0 1 0 2 1 0 0 0 1 1 0 0 0]\n",
      " [0 0 0 1 0 0 0 1 1 1 0 0 0 0 0 0 0 1 3 0 0 0 0 1 0 0 0 0 2 0 0 0 0 0 1 1]\n",
      " [1 1 0 0 4 3 0 0 0 0 1 1 0 1 0 1 1 0 1 0 0 1 0 0 0 1 0 0 0 2 1 0 0 1 0 0]]\n"
     ]
    }
   ],
   "execution_count": 9
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T14:24:19.161711Z",
     "start_time": "2025-01-09T14:24:19.154669Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.preprocessing import MinMaxScaler\n",
    "\n",
    "def mm():\n",
    "    \"\"\"\n",
    "    归一化处理\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # 归一化的缺点：容易受极值的影响，即数据中的极大值或极小值可能会导致归一化后的数据范围不准确\n",
    "    # MinMaxScaler 用于将数据缩放到指定的最小值和最大值范围内，常用的范围是 (0, 1) 或者 (-1, 1)\n",
    "    # feature_range=(0, 1) 表示将特征缩放到 [0, 1] 范围内，默认是 (0, 1)\n",
    "    mm = MinMaxScaler(feature_range=(0, 1))\n",
    "\n",
    "    # 使用 fit_transform 对数据进行归一化处理\n",
    "    # fit_transform 会先根据数据的最小值和最大值进行拟合，然后进行转换\n",
    "    data = mm.fit_transform([[90, 2, 10, 40], [60, 4, 15, 45], [75, 3, 13, 46]])\n",
    "\n",
    "    # 打印归一化后的数据\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "\n",
    "    # 使用 transform 对新数据进行归一化处理\n",
    "    # transform 仅根据先前拟合的数据进行转换，不会重新计算最小值和最大值\n",
    "    out = mm.transform([[1, 2, 3, 4], [6, 5, 8, 7]])\n",
    "\n",
    "    # 打印经过归一化处理的新数据\n",
    "    print(out)\n",
    "    return None\n",
    "    # transform 和 fit_transform 的区别：\n",
    "    # fit_transform 用于训练数据，既拟合数据又转换数据；\n",
    "    # transform 用于测试数据，使用已拟合的参数进行转换，不会重新计算最小值和最大值\n",
    "\n",
    "# 调用 mm 函数进行归一化处理\n",
    "mm()\n"
   ],
   "id": "307d9c56c76ebaa8",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         0.         0.         0.        ]\n",
      " [0.         1.         1.         0.83333333]\n",
      " [0.5        0.5        0.6        1.        ]]\n",
      "--------------------------------------------------\n",
      "[[-1.96666667  0.         -1.4        -6.        ]\n",
      " [-1.8         1.5        -0.4        -5.5       ]]\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T14:24:34.866540Z",
     "start_time": "2025-01-09T14:24:34.857291Z"
    }
   },
   "cell_type": "code",
   "source": "(1 - 60) / 30",
   "id": "4860ec0a91d3f8e8",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.9666666666666666"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 11
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T14:24:49.357943Z",
     "start_time": "2025-01-09T14:24:49.350771Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def stand():\n",
    "    \"\"\"\n",
    "    标准化缩放，不是标准正太分布，只均值为0，方差为1的分布\n",
    "    :return:\n",
    "    \"\"\"\n",
    "    std = StandardScaler()\n",
    "\n",
    "    data = std.fit_transform([[1., -1., 3.],\n",
    "                              [2., 4., 2.],\n",
    "                              [4., 6., -1.]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    print(std.mean_)\n",
    "    print('-' * 50)\n",
    "    print(std.var_)  #方差\n",
    "    print(std.n_samples_seen_)  # 样本数\n",
    "    return data\n",
    "\n",
    "\n",
    "data = stand()"
   ],
   "id": "58a81ce84ead9d42",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[-1.06904497 -1.35873244  0.98058068]\n",
      " [-0.26726124  0.33968311  0.39223227]\n",
      " [ 1.33630621  1.01904933 -1.37281295]]\n",
      "--------------------------------------------------\n",
      "[2.33333333 3.         1.33333333]\n",
      "--------------------------------------------------\n",
      "[1.55555556 8.66666667 2.88888889]\n",
      "3\n"
     ]
    }
   ],
   "execution_count": 12
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T14:25:02.345718Z",
     "start_time": "2025-01-09T14:25:02.341302Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#如何求方差\n",
    "(np.square(1 - 2.333) + np.square(2 - 2.333) + np.square(4 - 2.333)) / 3"
   ],
   "id": "78e2dd7eda35c32",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(1.5555556666666668)"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 13
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T14:25:10.623650Z",
     "start_time": "2025-01-09T14:25:10.619532Z"
    }
   },
   "cell_type": "code",
   "source": "type(data)",
   "id": "ea15f3ff36060b81",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "numpy.ndarray"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 14
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T14:25:19.886937Z",
     "start_time": "2025-01-09T14:25:19.881864Z"
    }
   },
   "cell_type": "code",
   "source": [
    "std1 = StandardScaler()\n",
    "#为了证明上面输出的结果的均值是为0的，方差为1\n",
    "data1 = std1.fit_transform([[-1.06904497, -1.35873244, 0.98058068],\n",
    "                            [-0.26726124, 0.33968311, 0.39223227],\n",
    "                            [1.33630621, 1.01904933, -1.37281295]])\n",
    "# print(data1)  #这个并不是我们想看的，没意义\n",
    "# 均值\n",
    "print(std1.mean_)\n",
    "# 方差\n",
    "print(std1.var_)"
   ],
   "id": "49594c904be759af",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0. 0. 0.]\n",
      "[1.         1.         1.00000001]\n"
     ]
    }
   ],
   "execution_count": 15
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T14:25:31.019631Z",
     "start_time": "2025-01-09T14:25:31.015457Z"
    }
   },
   "cell_type": "code",
   "source": "(np.square(1 - 2.333) + np.square(2 - 2.333) + np.square(4 - 2.333)) / 3",
   "id": "6843401c25b12c67",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(1.5555556666666668)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 16
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T14:25:38.590897Z",
     "start_time": "2025-01-09T14:25:38.585875Z"
    }
   },
   "cell_type": "code",
   "source": "(1 - 2.333) / np.sqrt(1.55555)",
   "id": "4f471beef634b1a9",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "np.float64(-1.068779614944516)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 17
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T14:26:33.889574Z",
     "start_time": "2025-01-09T14:26:33.880688Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import numpy as np\n",
    "from sklearn.impute import SimpleImputer\n",
    "\n",
    "def im():\n",
    "    \"\"\"\n",
    "    缺失值处理\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # SimpleImputer 用于填补缺失值\n",
    "    # missing_values=np.nan 表示我们要处理的数据中缺失值的形式是 NaN（缺失值）。\n",
    "    # strategy='mean' 表示用均值填补缺失值。除了均值，还可以选择'median'（中位数）、'most_frequent'（众数）、'constant'（常数值）等填补策略。\n",
    "    \n",
    "    im = SimpleImputer(missing_values=np.nan, strategy='mean')  # 使用均值填补缺失值\n",
    "\n",
    "    # 对数据进行填补，fit_transform 会计算填补策略（这里是均值），并填补缺失值\n",
    "    data = im.fit_transform([[1, 2], [np.nan, 3], [7, 6], [3, 2]])\n",
    "\n",
    "    # 打印填补后的数据\n",
    "    print(data)\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "# 调用 im 函数进行缺失值处理\n",
    "im()"
   ],
   "id": "844a01b0d981c4f3",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1.         2.        ]\n",
      " [3.66666667 3.        ]\n",
      " [7.         6.        ]\n",
      " [3.         2.        ]]\n"
     ]
    }
   ],
   "execution_count": 18
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T14:26:44.499599Z",
     "start_time": "2025-01-09T14:26:44.494651Z"
    }
   },
   "cell_type": "code",
   "source": "11 / 3",
   "id": "be0a78bcd302b7fe",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.6666666666666665"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 19
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T14:26:51.005299Z",
     "start_time": "2025-01-09T14:26:51.001164Z"
    }
   },
   "cell_type": "code",
   "source": "np.nan + 10",
   "id": "9ab4b570535eaef5",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "nan"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 20
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T14:49:18.232360Z",
     "start_time": "2025-01-09T14:49:18.227102Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def var():\n",
    "    \"\"\"\n",
    "    特征选择-删除低方差的特征\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    #默认只删除方差为0,threshold是方差阈值，删除比这个值小的那些特征\n",
    "    var = VarianceThreshold(threshold=0.1)\n",
    "\n",
    "    data = var.fit_transform([[0, 2, 0, 3],\n",
    "                              [0, 1, 4, 3],\n",
    "                              [0, 1, 1, 3]])\n",
    "\n",
    "    print(data)\n",
    "    print('-' * 50)\n",
    "    # 获得剩余的特征的列编号\n",
    "    print('The surport is %s' % var.get_support(True))\n",
    "    return None\n",
    "\n",
    "\n",
    "var()"
   ],
   "id": "d16172392c840178",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2 0]\n",
      " [1 4]\n",
      " [1 1]]\n",
      "--------------------------------------------------\n",
      "The surport is [1 2]\n"
     ]
    }
   ],
   "execution_count": 21
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T14:49:35.326248Z",
     "start_time": "2025-01-09T14:49:35.307906Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def pca():\n",
    "    \"\"\"\n",
    "    主成分分析进行特征降维\n",
    "    :return: None\n",
    "    \"\"\"\n",
    "    # n_ components:小数 0~1 90% 业界选择 90~95%\n",
    "\n",
    "    # 当n_components的值为0到1之间的浮点数时，表示我们希望保留的主成分解释的方差比例。方差比例是指 得到输出的每一列的方差值和除以原有数据方差之和。\n",
    "    # 具体而言，n_components=0.9表示我们希望选择足够的主成分，以使它们解释数据方差的90%。\n",
    "\n",
    "    # n_components如果是整数   减少到的特征数量\n",
    "    # 原始数据方差\n",
    "    original_value = np.array([[2, 8, 4, 5],\n",
    "                               [6, 3, 0, 8],\n",
    "                               [5, 4, 9, 1]])\n",
    "    print(np.var(original_value, axis=0).sum())  #最初数据每一列的方差，求和\n",
    "    print('-' * 50)\n",
    "    pca = PCA(n_components=0.99)\n",
    "\n",
    "    data = pca.fit_transform(original_value)\n",
    "\n",
    "    print(data)\n",
    "    print(type(data))\n",
    "    #计算data的方差和\n",
    "    print(np.var(data, axis=0).sum())\n",
    "    print('-' * 50)\n",
    "    print(pca.explained_variance_ratio_)\n",
    "    # 计算data的方差占总方差的比例\n",
    "    print(pca.explained_variance_ratio_.sum())\n",
    "\n",
    "    return None\n",
    "\n",
    "\n",
    "pca()"
   ],
   "id": "a0cf333a09ff404a",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "29.333333333333336\n",
      "--------------------------------------------------\n",
      "[[-1.28620952e-15  3.82970843e+00]\n",
      " [-5.74456265e+00 -1.91485422e+00]\n",
      " [ 5.74456265e+00 -1.91485422e+00]]\n",
      "<class 'numpy.ndarray'>\n",
      "29.333333333333332\n",
      "--------------------------------------------------\n",
      "[0.75 0.25]\n",
      "1.0\n"
     ]
    }
   ],
   "execution_count": 22
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T14:49:45.155729Z",
     "start_time": "2025-01-09T14:49:45.150680Z"
    }
   },
   "cell_type": "code",
   "source": "22 / 29.333333333333336",
   "id": "7d4a2ffe11b3c34a",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.7499999999999999"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 23
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-09T14:50:41.225036Z",
     "start_time": "2025-01-09T14:50:40.149224Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from matplotlib import pyplot as plt\n",
    "\n",
    "x = np.random.rand(10000)  #每个的概率\n",
    "t = np.arange(len(x))\n",
    "plt.plot(t, x, 'g.', label=\"Uniform Distribution\")\n",
    "plt.legend(loc=\"upper left\")\n",
    "plt.grid()\n",
    "plt.show()"
   ],
   "id": "154032a8b9745cf1",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 24
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-10T13:33:23.585079Z",
     "start_time": "2025-01-10T13:33:16.599998Z"
    }
   },
   "cell_type": "code",
   "source": [
    "import time\n",
    "\n",
    "from sklearn.datasets import load_iris, fetch_20newsgroups, fetch_california_housing\n",
    "from sklearn.model_selection import train_test_split, GridSearchCV\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from sklearn.feature_extraction.text import TfidfVectorizer\n",
    "from sklearn.naive_bayes import MultinomialNB\n",
    "from sklearn.metrics import classification_report\n",
    "from sklearn.feature_extraction import DictVectorizer\n",
    "from sklearn.tree import DecisionTreeClassifier, export_graphviz\n",
    "from sklearn.ensemble import RandomForestClassifier\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "from sklearn.metrics import roc_auc_score"
   ],
   "id": "258e44df6433739f",
   "outputs": [],
   "execution_count": 1
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-10T13:33:24.900527Z",
     "start_time": "2025-01-10T13:33:24.868580Z"
    }
   },
   "cell_type": "code",
   "source": [
    "#鸢尾花数据集，查看特征，目标，样本量\n",
    "\n",
    "li = load_iris()\n",
    "\n",
    "print(\"获取特征值\")\n",
    "print(type(li.data))\n",
    "print('-' * 50)\n",
    "print(li.data.shape) # 150个样本，4个特征,一般看shape\n",
    "li.data"
   ],
   "id": "f1130dbba5c34993",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "获取特征值\n",
      "<class 'numpy.ndarray'>\n",
      "--------------------------------------------------\n",
      "(150, 4)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[5.1, 3.5, 1.4, 0.2],\n",
       "       [4.9, 3. , 1.4, 0.2],\n",
       "       [4.7, 3.2, 1.3, 0.2],\n",
       "       [4.6, 3.1, 1.5, 0.2],\n",
       "       [5. , 3.6, 1.4, 0.2],\n",
       "       [5.4, 3.9, 1.7, 0.4],\n",
       "       [4.6, 3.4, 1.4, 0.3],\n",
       "       [5. , 3.4, 1.5, 0.2],\n",
       "       [4.4, 2.9, 1.4, 0.2],\n",
       "       [4.9, 3.1, 1.5, 0.1],\n",
       "       [5.4, 3.7, 1.5, 0.2],\n",
       "       [4.8, 3.4, 1.6, 0.2],\n",
       "       [4.8, 3. , 1.4, 0.1],\n",
       "       [4.3, 3. , 1.1, 0.1],\n",
       "       [5.8, 4. , 1.2, 0.2],\n",
       "       [5.7, 4.4, 1.5, 0.4],\n",
       "       [5.4, 3.9, 1.3, 0.4],\n",
       "       [5.1, 3.5, 1.4, 0.3],\n",
       "       [5.7, 3.8, 1.7, 0.3],\n",
       "       [5.1, 3.8, 1.5, 0.3],\n",
       "       [5.4, 3.4, 1.7, 0.2],\n",
       "       [5.1, 3.7, 1.5, 0.4],\n",
       "       [4.6, 3.6, 1. , 0.2],\n",
       "       [5.1, 3.3, 1.7, 0.5],\n",
       "       [4.8, 3.4, 1.9, 0.2],\n",
       "       [5. , 3. , 1.6, 0.2],\n",
       "       [5. , 3.4, 1.6, 0.4],\n",
       "       [5.2, 3.5, 1.5, 0.2],\n",
       "       [5.2, 3.4, 1.4, 0.2],\n",
       "       [4.7, 3.2, 1.6, 0.2],\n",
       "       [4.8, 3.1, 1.6, 0.2],\n",
       "       [5.4, 3.4, 1.5, 0.4],\n",
       "       [5.2, 4.1, 1.5, 0.1],\n",
       "       [5.5, 4.2, 1.4, 0.2],\n",
       "       [4.9, 3.1, 1.5, 0.2],\n",
       "       [5. , 3.2, 1.2, 0.2],\n",
       "       [5.5, 3.5, 1.3, 0.2],\n",
       "       [4.9, 3.6, 1.4, 0.1],\n",
       "       [4.4, 3. , 1.3, 0.2],\n",
       "       [5.1, 3.4, 1.5, 0.2],\n",
       "       [5. , 3.5, 1.3, 0.3],\n",
       "       [4.5, 2.3, 1.3, 0.3],\n",
       "       [4.4, 3.2, 1.3, 0.2],\n",
       "       [5. , 3.5, 1.6, 0.6],\n",
       "       [5.1, 3.8, 1.9, 0.4],\n",
       "       [4.8, 3. , 1.4, 0.3],\n",
       "       [5.1, 3.8, 1.6, 0.2],\n",
       "       [4.6, 3.2, 1.4, 0.2],\n",
       "       [5.3, 3.7, 1.5, 0.2],\n",
       "       [5. , 3.3, 1.4, 0.2],\n",
       "       [7. , 3.2, 4.7, 1.4],\n",
       "       [6.4, 3.2, 4.5, 1.5],\n",
       "       [6.9, 3.1, 4.9, 1.5],\n",
       "       [5.5, 2.3, 4. , 1.3],\n",
       "       [6.5, 2.8, 4.6, 1.5],\n",
       "       [5.7, 2.8, 4.5, 1.3],\n",
       "       [6.3, 3.3, 4.7, 1.6],\n",
       "       [4.9, 2.4, 3.3, 1. ],\n",
       "       [6.6, 2.9, 4.6, 1.3],\n",
       "       [5.2, 2.7, 3.9, 1.4],\n",
       "       [5. , 2. , 3.5, 1. ],\n",
       "       [5.9, 3. , 4.2, 1.5],\n",
       "       [6. , 2.2, 4. , 1. ],\n",
       "       [6.1, 2.9, 4.7, 1.4],\n",
       "       [5.6, 2.9, 3.6, 1.3],\n",
       "       [6.7, 3.1, 4.4, 1.4],\n",
       "       [5.6, 3. , 4.5, 1.5],\n",
       "       [5.8, 2.7, 4.1, 1. ],\n",
       "       [6.2, 2.2, 4.5, 1.5],\n",
       "       [5.6, 2.5, 3.9, 1.1],\n",
       "       [5.9, 3.2, 4.8, 1.8],\n",
       "       [6.1, 2.8, 4. , 1.3],\n",
       "       [6.3, 2.5, 4.9, 1.5],\n",
       "       [6.1, 2.8, 4.7, 1.2],\n",
       "       [6.4, 2.9, 4.3, 1.3],\n",
       "       [6.6, 3. , 4.4, 1.4],\n",
       "       [6.8, 2.8, 4.8, 1.4],\n",
       "       [6.7, 3. , 5. , 1.7],\n",
       "       [6. , 2.9, 4.5, 1.5],\n",
       "       [5.7, 2.6, 3.5, 1. ],\n",
       "       [5.5, 2.4, 3.8, 1.1],\n",
       "       [5.5, 2.4, 3.7, 1. ],\n",
       "       [5.8, 2.7, 3.9, 1.2],\n",
       "       [6. , 2.7, 5.1, 1.6],\n",
       "       [5.4, 3. , 4.5, 1.5],\n",
       "       [6. , 3.4, 4.5, 1.6],\n",
       "       [6.7, 3.1, 4.7, 1.5],\n",
       "       [6.3, 2.3, 4.4, 1.3],\n",
       "       [5.6, 3. , 4.1, 1.3],\n",
       "       [5.5, 2.5, 4. , 1.3],\n",
       "       [5.5, 2.6, 4.4, 1.2],\n",
       "       [6.1, 3. , 4.6, 1.4],\n",
       "       [5.8, 2.6, 4. , 1.2],\n",
       "       [5. , 2.3, 3.3, 1. ],\n",
       "       [5.6, 2.7, 4.2, 1.3],\n",
       "       [5.7, 3. , 4.2, 1.2],\n",
       "       [5.7, 2.9, 4.2, 1.3],\n",
       "       [6.2, 2.9, 4.3, 1.3],\n",
       "       [5.1, 2.5, 3. , 1.1],\n",
       "       [5.7, 2.8, 4.1, 1.3],\n",
       "       [6.3, 3.3, 6. , 2.5],\n",
       "       [5.8, 2.7, 5.1, 1.9],\n",
       "       [7.1, 3. , 5.9, 2.1],\n",
       "       [6.3, 2.9, 5.6, 1.8],\n",
       "       [6.5, 3. , 5.8, 2.2],\n",
       "       [7.6, 3. , 6.6, 2.1],\n",
       "       [4.9, 2.5, 4.5, 1.7],\n",
       "       [7.3, 2.9, 6.3, 1.8],\n",
       "       [6.7, 2.5, 5.8, 1.8],\n",
       "       [7.2, 3.6, 6.1, 2.5],\n",
       "       [6.5, 3.2, 5.1, 2. ],\n",
       "       [6.4, 2.7, 5.3, 1.9],\n",
       "       [6.8, 3. , 5.5, 2.1],\n",
       "       [5.7, 2.5, 5. , 2. ],\n",
       "       [5.8, 2.8, 5.1, 2.4],\n",
       "       [6.4, 3.2, 5.3, 2.3],\n",
       "       [6.5, 3. , 5.5, 1.8],\n",
       "       [7.7, 3.8, 6.7, 2.2],\n",
       "       [7.7, 2.6, 6.9, 2.3],\n",
       "       [6. , 2.2, 5. , 1.5],\n",
       "       [6.9, 3.2, 5.7, 2.3],\n",
       "       [5.6, 2.8, 4.9, 2. ],\n",
       "       [7.7, 2.8, 6.7, 2. ],\n",
       "       [6.3, 2.7, 4.9, 1.8],\n",
       "       [6.7, 3.3, 5.7, 2.1],\n",
       "       [7.2, 3.2, 6. , 1.8],\n",
       "       [6.2, 2.8, 4.8, 1.8],\n",
       "       [6.1, 3. , 4.9, 1.8],\n",
       "       [6.4, 2.8, 5.6, 2.1],\n",
       "       [7.2, 3. , 5.8, 1.6],\n",
       "       [7.4, 2.8, 6.1, 1.9],\n",
       "       [7.9, 3.8, 6.4, 2. ],\n",
       "       [6.4, 2.8, 5.6, 2.2],\n",
       "       [6.3, 2.8, 5.1, 1.5],\n",
       "       [6.1, 2.6, 5.6, 1.4],\n",
       "       [7.7, 3. , 6.1, 2.3],\n",
       "       [6.3, 3.4, 5.6, 2.4],\n",
       "       [6.4, 3.1, 5.5, 1.8],\n",
       "       [6. , 3. , 4.8, 1.8],\n",
       "       [6.9, 3.1, 5.4, 2.1],\n",
       "       [6.7, 3.1, 5.6, 2.4],\n",
       "       [6.9, 3.1, 5.1, 2.3],\n",
       "       [5.8, 2.7, 5.1, 1.9],\n",
       "       [6.8, 3.2, 5.9, 2.3],\n",
       "       [6.7, 3.3, 5.7, 2.5],\n",
       "       [6.7, 3. , 5.2, 2.3],\n",
       "       [6.3, 2.5, 5. , 1.9],\n",
       "       [6.5, 3. , 5.2, 2. ],\n",
       "       [6.2, 3.4, 5.4, 2.3],\n",
       "       [5.9, 3. , 5.1, 1.8]])"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 2
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-10T13:33:40.268454Z",
     "start_time": "2025-01-10T13:33:40.264350Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print(\"目标值\")\n",
    "print(li.target)\n",
    "print('-' * 50)\n",
    "print(li.DESCR)\n",
    "print('-' * 50)\n",
    "print(li.feature_names)  # 重点,特征名字\n",
    "print('-' * 50)\n",
    "print(li.target_names) # 目标名字"
   ],
   "id": "22db239e949c4c2d",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "目标值\n",
      "[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
      " 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n",
      " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2\n",
      " 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2\n",
      " 2 2]\n",
      "--------------------------------------------------\n",
      ".. _iris_dataset:\n",
      "\n",
      "Iris plants dataset\n",
      "--------------------\n",
      "\n",
      "**Data Set Characteristics:**\n",
      "\n",
      ":Number of Instances: 150 (50 in each of three classes)\n",
      ":Number of Attributes: 4 numeric, predictive attributes and the class\n",
      ":Attribute Information:\n",
      "    - sepal length in cm\n",
      "    - sepal width in cm\n",
      "    - petal length in cm\n",
      "    - petal width in cm\n",
      "    - class:\n",
      "            - Iris-Setosa\n",
      "            - Iris-Versicolour\n",
      "            - Iris-Virginica\n",
      "\n",
      ":Summary Statistics:\n",
      "\n",
      "============== ==== ==== ======= ===== ====================\n",
      "                Min  Max   Mean    SD   Class Correlation\n",
      "============== ==== ==== ======= ===== ====================\n",
      "sepal length:   4.3  7.9   5.84   0.83    0.7826\n",
      "sepal width:    2.0  4.4   3.05   0.43   -0.4194\n",
      "petal length:   1.0  6.9   3.76   1.76    0.9490  (high!)\n",
      "petal width:    0.1  2.5   1.20   0.76    0.9565  (high!)\n",
      "============== ==== ==== ======= ===== ====================\n",
      "\n",
      ":Missing Attribute Values: None\n",
      ":Class Distribution: 33.3% for each of 3 classes.\n",
      ":Creator: R.A. Fisher\n",
      ":Donor: Michael Marshall (MARSHALL%PLU@io.arc.nasa.gov)\n",
      ":Date: July, 1988\n",
      "\n",
      "The famous Iris database, first used by Sir R.A. Fisher. The dataset is taken\n",
      "from Fisher's paper. Note that it's the same as in R, but not as in the UCI\n",
      "Machine Learning Repository, which has two wrong data points.\n",
      "\n",
      "This is perhaps the best known database to be found in the\n",
      "pattern recognition literature.  Fisher's paper is a classic in the field and\n",
      "is referenced frequently to this day.  (See Duda & Hart, for example.)  The\n",
      "data set contains 3 classes of 50 instances each, where each class refers to a\n",
      "type of iris plant.  One class is linearly separable from the other 2; the\n",
      "latter are NOT linearly separable from each other.\n",
      "\n",
      ".. dropdown:: References\n",
      "\n",
      "  - Fisher, R.A. \"The use of multiple measurements in taxonomic problems\"\n",
      "    Annual Eugenics, 7, Part II, 179-188 (1936); also in \"Contributions to\n",
      "    Mathematical Statistics\" (John Wiley, NY, 1950).\n",
      "  - Duda, R.O., & Hart, P.E. (1973) Pattern Classification and Scene Analysis.\n",
      "    (Q327.D83) John Wiley & Sons.  ISBN 0-471-22361-1.  See page 218.\n",
      "  - Dasarathy, B.V. (1980) \"Nosing Around the Neighborhood: A New System\n",
      "    Structure and Classification Rule for Recognition in Partially Exposed\n",
      "    Environments\".  IEEE Transactions on Pattern Analysis and Machine\n",
      "    Intelligence, Vol. PAMI-2, No. 1, 67-71.\n",
      "  - Gates, G.W. (1972) \"The Reduced Nearest Neighbor Rule\".  IEEE Transactions\n",
      "    on Information Theory, May 1972, 431-433.\n",
      "  - See also: 1988 MLC Proceedings, 54-64.  Cheeseman et al\"s AUTOCLASS II\n",
      "    conceptual clustering system finds 3 classes in the data.\n",
      "  - Many, many more ...\n",
      "\n",
      "--------------------------------------------------\n",
      "['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']\n",
      "--------------------------------------------------\n",
      "['setosa' 'versicolor' 'virginica']\n"
     ]
    }
   ],
   "execution_count": 3
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-10T13:33:52.588142Z",
     "start_time": "2025-01-10T13:33:52.583954Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print(li.data.shape)\n",
    "li.target.shape"
   ],
   "id": "c5c79202ad3f3c89",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(150, 4)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(150,)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 4
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-10T13:34:02.519594Z",
     "start_time": "2025-01-10T13:34:02.509319Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 注意返回值, 训练集 train  x_train, y_train        测试集  test   x_test, y_test，顺序千万别搞错了\n",
    "# 默认是乱序的,random_state为了确保两次的随机策略一致，就会得到相同的随机数据，往往会带上\n",
    "x_train, x_test, y_train, y_test = train_test_split(li.data, li.target, test_size=0.25, random_state=1)\n",
    "\n",
    "# print(\"训练集特征值和目标值：\", x_train, y_train)\n",
    "print(\"训练集特征值shape\", x_train.shape)\n",
    "print('-'*50)\n",
    "# print(\"测试集特征值和目标值：\", x_test, y_test)\n",
    "print(\"测试集特征值shape\", x_test.shape)"
   ],
   "id": "ed03118019987ccf",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集特征值shape (112, 4)\n",
      "--------------------------------------------------\n",
      "测试集特征值shape (38, 4)\n"
     ]
    }
   ],
   "execution_count": 5
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-10T13:34:13.298751Z",
     "start_time": "2025-01-10T13:34:13.295233Z"
    }
   },
   "cell_type": "code",
   "source": "150*0.25",
   "id": "c89126bc5dbb6a25",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "37.5"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 6
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-10T13:37:12.313151Z",
     "start_time": "2025-01-10T13:34:23.266306Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 下面是比较大的数据，需要下载一会，20类新闻\n",
    "#subset代表下载的数据集类型，默认是train，只有训练集\n",
    "news = fetch_20newsgroups(subset='all', data_home='data')\n",
    "# print(news.feature_names)  #这个数据集是没有的，因为没有特征，只有文本数据\n",
    "# print(news.DESCR)\n",
    "print('第一个样本')\n",
    "print(news.data[0])"
   ],
   "id": "6045b79641539c91",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "第一个样本\n",
      "From: Mamatha Devineni Ratnam <mr47+@andrew.cmu.edu>\n",
      "Subject: Pens fans reactions\n",
      "Organization: Post Office, Carnegie Mellon, Pittsburgh, PA\n",
      "Lines: 12\n",
      "NNTP-Posting-Host: po4.andrew.cmu.edu\n",
      "\n",
      "\n",
      "\n",
      "I am sure some bashers of Pens fans are pretty confused about the lack\n",
      "of any kind of posts about the recent Pens massacre of the Devils. Actually,\n",
      "I am  bit puzzled too and a bit relieved. However, I am going to put an end\n",
      "to non-PIttsburghers' relief with a bit of praise for the Pens. Man, they\n",
      "are killing those Devils worse than I thought. Jagr just showed you why\n",
      "he is much better than his regular season stats. He is also a lot\n",
      "fo fun to watch in the playoffs. Bowman should let JAgr have a lot of\n",
      "fun in the next couple of games since the Pens are going to beat the pulp out of Jersey anyway. I was very disappointed not to see the Islanders lose the final\n",
      "regular season game.          PENS RULE!!!\n",
      "\n",
      "\n"
     ]
    }
   ],
   "execution_count": 7
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-10T13:44:02.181661Z",
     "start_time": "2025-01-10T13:44:02.177163Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print('特征类型')\n",
    "print(type(news.data))\n",
    "print('-' * 50)\n",
    "print(news.target[0:15])\n",
    "from pprint import pprint\n",
    "pprint(list(news.target_names))"
   ],
   "id": "f1cd6e02acb3fd62",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "特征类型\n",
      "<class 'list'>\n",
      "--------------------------------------------------\n",
      "[10  3 17  3  4 12  4 10 10 19 19 11 19 13  0]\n",
      "['alt.atheism',\n",
      " 'comp.graphics',\n",
      " 'comp.os.ms-windows.misc',\n",
      " 'comp.sys.ibm.pc.hardware',\n",
      " 'comp.sys.mac.hardware',\n",
      " 'comp.windows.x',\n",
      " 'misc.forsale',\n",
      " 'rec.autos',\n",
      " 'rec.motorcycles',\n",
      " 'rec.sport.baseball',\n",
      " 'rec.sport.hockey',\n",
      " 'sci.crypt',\n",
      " 'sci.electronics',\n",
      " 'sci.med',\n",
      " 'sci.space',\n",
      " 'soc.religion.christian',\n",
      " 'talk.politics.guns',\n",
      " 'talk.politics.mideast',\n",
      " 'talk.politics.misc',\n",
      " 'talk.religion.misc']\n"
     ]
    }
   ],
   "execution_count": 8
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-10T13:44:18.394048Z",
     "start_time": "2025-01-10T13:44:18.389629Z"
    }
   },
   "cell_type": "code",
   "source": "len(news.target_names)",
   "id": "10f68c673d97a842",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 9
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-10T13:44:29.350870Z",
     "start_time": "2025-01-10T13:44:29.344871Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print('-' * 50)\n",
    "print(len(news.data))\n",
    "print('新闻所有的标签')\n",
    "print(news.target)\n",
    "print('-' * 50)\n",
    "print(min(news.target), max(news.target))"
   ],
   "id": "ce5b022f6732f137",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "--------------------------------------------------\n",
      "18846\n",
      "新闻所有的标签\n",
      "[10  3 17 ...  3  1  7]\n",
      "--------------------------------------------------\n",
      "0 19\n"
     ]
    }
   ],
   "execution_count": 10
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-10T13:44:50.024061Z",
     "start_time": "2025-01-10T13:44:43.926568Z"
    }
   },
   "cell_type": "code",
   "source": [
    "house=fetch_california_housing(data_home='data')\n",
    "print(\"获取特征值\")\n",
    "print(house.data[0])  #第一个样本特征值\n",
    "print('样本的形状')\n",
    "print(house.data.shape)\n",
    "print('-' * 50)\n"
   ],
   "id": "7f2d9fd5f92fae14",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "获取特征值\n",
      "[   8.3252       41.            6.98412698    1.02380952  322.\n",
      "    2.55555556   37.88       -122.23      ]\n",
      "样本的形状\n",
      "(20640, 8)\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "execution_count": 11
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-10T13:45:01.927670Z",
     "start_time": "2025-01-10T13:45:01.923428Z"
    }
   },
   "cell_type": "code",
   "source": [
    "print(\"目标值\")\n",
    "print(house.target[0:10])\n",
    "print('-' * 50)\n",
    "print(house.DESCR)\n",
    "print('-' * 50)\n",
    "print(house.feature_names)\n",
    "print('-' * 50)"
   ],
   "id": "959be5c4a87acbda",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "目标值\n",
      "[4.526 3.585 3.521 3.413 3.422 2.697 2.992 2.414 2.267 2.611]\n",
      "--------------------------------------------------\n",
      ".. _california_housing_dataset:\n",
      "\n",
      "California Housing dataset\n",
      "--------------------------\n",
      "\n",
      "**Data Set Characteristics:**\n",
      "\n",
      ":Number of Instances: 20640\n",
      "\n",
      ":Number of Attributes: 8 numeric, predictive attributes and the target\n",
      "\n",
      ":Attribute Information:\n",
      "    - MedInc        median income in block group\n",
      "    - HouseAge      median house age in block group\n",
      "    - AveRooms      average number of rooms per household\n",
      "    - AveBedrms     average number of bedrooms per household\n",
      "    - Population    block group population\n",
      "    - AveOccup      average number of household members\n",
      "    - Latitude      block group latitude\n",
      "    - Longitude     block group longitude\n",
      "\n",
      ":Missing Attribute Values: None\n",
      "\n",
      "This dataset was obtained from the StatLib repository.\n",
      "https://www.dcc.fc.up.pt/~ltorgo/Regression/cal_housing.html\n",
      "\n",
      "The target variable is the median house value for California districts,\n",
      "expressed in hundreds of thousands of dollars ($100,000).\n",
      "\n",
      "This dataset was derived from the 1990 U.S. census, using one row per census\n",
      "block group. A block group is the smallest geographical unit for which the U.S.\n",
      "Census Bureau publishes sample data (a block group typically has a population\n",
      "of 600 to 3,000 people).\n",
      "\n",
      "A household is a group of people residing within a home. Since the average\n",
      "number of rooms and bedrooms in this dataset are provided per household, these\n",
      "columns may take surprisingly large values for block groups with few households\n",
      "and many empty houses, such as vacation resorts.\n",
      "\n",
      "It can be downloaded/loaded using the\n",
      ":func:`sklearn.datasets.fetch_california_housing` function.\n",
      "\n",
      ".. rubric:: References\n",
      "\n",
      "- Pace, R. Kelley and Ronald Barry, Sparse Spatial Autoregressions,\n",
      "  Statistics and Probability Letters, 33 (1997) 291-297\n",
      "\n",
      "--------------------------------------------------\n",
      "['MedInc', 'HouseAge', 'AveRooms', 'AveBedrms', 'Population', 'AveOccup', 'Latitude', 'Longitude']\n",
      "--------------------------------------------------\n"
     ]
    }
   ],
   "execution_count": 12
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
